package org.example;

import model.Product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Comparator;
import java.io.*;
import java.util.List;
import java.util.Map;
import java.util.Properties;
/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private Map<String, Product> productData = new HashMap<>();
    //private static final String DATA_FILE = "products.dat";
    private String dataFilePath; // 从配置文件读取的文件路径

    public ProductService() {
        loadConfig();// 先加载配置，再加载数据
        // 在构造函数中加载数据
        loadData();
        if (productData.isEmpty()) {
            initializeProductsWithTags();
        }
    }

    /**
     * 加载配置文件
     */
    private void loadConfig() {
        Properties props = new Properties();
        File configFile = new File("config.properties");

        try (InputStreamReader reader = new InputStreamReader(
                new FileInputStream(configFile), "UTF-8")) {

            props.load(reader);
            dataFilePath = props.getProperty("data.file.path", "products.dat");
            System.out.println("配置文件加载成功，数据文件路径: " + dataFilePath);

        } catch (FileNotFoundException e) {
            System.err.println("配置文件不存在，使用默认路径: products.dat");
            dataFilePath = "products.dat";
            // 创建默认配置文件
            createDefaultConfig();
        } catch (IOException e) {
            System.err.println("加载配置文件失败: " + e.getMessage());
            dataFilePath = "products.dat";
        }
    }

    /**
     * 创建默认配置文件
     */
    private void createDefaultConfig() {
        Properties props = new Properties();
        props.setProperty("data.file.path", "products.dat");

        try (OutputStreamWriter writer = new OutputStreamWriter(
                new FileOutputStream("config.properties"), "UTF-8")) {

            props.store(writer, "商品数据文件配置");
            System.out.println("已创建默认配置文件: config.properties");

        } catch (IOException e) {
            System.err.println("创建配置文件失败: " + e.getMessage());
        }
    }

    /**
     * 保存数据到文件
     */
    public void saveData() {
        if (dataFilePath == null) {
            dataFilePath = "products.dat"; // 确保有默认值
        }
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(dataFilePath))) {
            oos.writeObject(productData);
            System.out.println("商品数据已保存到文件: " + dataFilePath);
        } catch (IOException e) {
            System.err.println("保存数据失败: " + e.getMessage());
            e.printStackTrace();
        }
    }

     /** 从文件加载数据
     */
    @SuppressWarnings("unchecked")
    public void loadData() {
        File file = new File(dataFilePath);
        if (!file.exists()) {
            System.out.println("数据文件不存在，将创建新文件");
            return;
        }
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(dataFilePath))) {
            productData = (Map<String, Product>) ois.readObject();
            System.out.println("商品数据已从文件加载: " + dataFilePath);
            System.out.println("加载了 " + productData.size() + " 个商品");
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("加载数据失败: " + e.getMessage());
            // 如果加载失败，初始化一个空的Map
            productData = new HashMap<>();
        }
    }

    /**
     * 备份数据文件
     * 使用最基础的 FileInputStream 和 FileOutputStream
     * 通过字节数组缓冲区进行文件复制
     */
    public boolean backupData() {
        if (dataFilePath == null) {
            dataFilePath = "products.dat";
        }

        String backupFilePath = dataFilePath + ".bak";
        File sourceFile = new File(dataFilePath);
        File backupFile = new File(backupFilePath);

        // 检查源文件是否存在
        if (!sourceFile.exists()) {
            System.err.println("备份失败：源数据文件不存在 - " + dataFilePath);
            return false;
        }

        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(backupFile)) {

            // 创建字节数组作为缓冲区（1024字节）
            byte[] buffer = new byte[1024];
            int bytesRead;

            // 通过循环，不断从源文件读取数据到缓冲区
            // 然后将缓冲区的数据写入到目标文件中
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }

            // 刷新输出流确保数据写入磁盘
            fos.flush();

            System.out.println("数据备份成功！");
            System.out.println("源文件: " + dataFilePath);
            System.out.println("备份文件: " + backupFilePath);
            System.out.println("备份大小: " + sourceFile.length() + " 字节");
            return true;

        } catch (IOException e) {
            System.err.println("备份失败: " + e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 检查备份文件是否存在
     */
    public boolean backupExists() {
        if (dataFilePath == null) {
            dataFilePath = "products.dat";
        }
        File backupFile = new File(dataFilePath + ".bak");
        return backupFile.exists();
    }

    /**
     * 获取备份文件信息
     */
    public String getBackupInfo() {
        if (dataFilePath == null) {
            dataFilePath = "products.dat";
        }
        File backupFile = new File(dataFilePath + ".bak");
        if (backupFile.exists()) {
            return "备份文件: " + backupFile.getName() + " (" + backupFile.length() + " 字节)";
        } else {
            return "暂无备份文件";
        }
    }



    /**
     * 初始化带标签的商品数据
     */
    private void initializeProductsWithTags() {
        // 商品1：Java从入门到精通 - 带有编程相关标签
        Product javaBook = new Product("p001", "Java从入门到精通", 99.0, 100);
        javaBook.addTag("编程");
        javaBook.addTag("热门");
        javaBook.addTag("新品");
        productData.put("p001", javaBook);

        // 商品2：高性能MySQL - 带有数据库标签
        Product mysqlBook = new Product("p002", "高性能MySQL", 128.5, 50);
        mysqlBook.addTag("数据库");
        mysqlBook.addTag("技术");
        productData.put("p002", mysqlBook);

        // 商品3：颈椎康复指南 - 带有健康标签
        Product healthBook = new Product("p003", "颈椎康复指南", 45.0, 200);
        healthBook.addTag("健康");
        healthBook.addTag("生活");
        healthBook.addTag("热门");
        productData.put("p003", healthBook);

        // 商品4：生发秘籍 - 无标签的商品（用于对比）
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 25));

        // 商品5：上课指南 - 带有教育标签
        Product studyBook = new Product("p005", "上课指南", 66.0, 150);
        studyBook.addTag("教育");
        studyBook.addTag("学习");
        productData.put("p005", studyBook);

        System.out.println("已初始化 " + productData.size() + " 个示例商品");
    }

    /**
     * 构造函数，初始化一些商品数据
     */
    /**
     public ProductService() {
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0)); // 库存为0的商品
        productData.put("p005", new Product("p005", "上课指南", 66.0, 150));
    }*/

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        // 从Map的值集合创建一个新的ArrayList并返回
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }
    /**
     * 添加商品
     */
    public boolean addProduct(Product product) {
        if (product == null || productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        return true;
    }
    /**
     * 更新商品
     */
    public boolean updateProduct(Product product) {
        if (product == null || !productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        return true;
    }
    /**
     * 删除商品
     */
    public boolean deleteProduct(String id) {
        return productData.remove(id) != null;
    }
    /**
     * 获取排序后的商品列表
     */
    public List<Product> getSortedProducts(Comparator<Product> comparator) {
        List<Product> products = new ArrayList<>(productData.values());
        if (comparator != null) {
            products.sort(comparator);
        } else {
            products.sort(null); // 使用自然排序
        }
        return products;
    }
    /**
     * 获取商品数量
     */
    public int getProductCount() {
        return productData.size();
    }
    /**
     * 获取当前使用的数据文件路径（用于测试）
     */
    public String getDataFilePath() {
        return dataFilePath;
    }
}